package javase基础;

import javase基础.继承与多态.多态.Animal;
import javase基础.继承与多态.多态.Dog;

/**
 * 向上转型:创建一个子类对象,将其当成父类对象来使用
 * 语法格式:父类类型 对象名 = new 子类类型()
 * Animal animal = new Cat("sd",2);
 *
 * 使用场景:1.直接赋值
 *         2.方法传参
 *         3.方法返回
 *
 * 向上转型的优点:让代码实现更加简单灵活
 * 向上转型的缺点:不能调用到子类特有的方法
 */
public class 向上转型和向下转型 {

    private static class Cat extends Animal {
        public Cat(String 猫, int i) {
            super();
        }

        public void mew() {
        }
    }/*
    //方法传参:形参为父类型引用,可以接收任意子类的对象
    public static void eatFood(Animal a){
        a.eat();
    }
    //作返回值:返回任意子类对象
    public static Animal buyAnimal(String var){
        if("狗".equals(var)){
            return new Dog("狗",1);
        }else if("猫".equals(var)){
            return new Cat("猫",1);
        }else{
            return null;
        }
    }

    public static void main(String[] args) {
        //直接赋值:对子类对象赋值给父类对象
        Animal cat = new Cat("sd",2);
        Dog dog = new Dog("dsf",1);
        eatFood(cat);
        eatFood(dog);
        Animal animal =buyAnimal("狗");
        animal.eat();
        animal = buyAnimal("猫");
        animal.eat();
    }

 */


    /**
     * 向下转型:将一个子类对象经过向上转型之后当成父类的方法使用,再无法调用子类的方法,但有时候可能需要调用子类特有的方法,此时将父类引用再还原为子列对象即可,即向下转型
     *
     */
    public static void main(String[] args) {
        Dog dog = new Dog("f",2);
        //向上转型
        Animal animal = dog;
        animal.eat();

        //抛出异常,因为animal实际指向狗,这儿强制还原为猫,无法正常还原
        Cat cat = (Cat) animal;
        cat.mew();
        //animal本来指向的就是狗,因此将animal还原为狗是安全的
        dog = (Dog)animal;
        dog.eat();
    }
}
